﻿using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using System.Windows.Controls.DataVisualization.Charting;
using Galaktika.BI.Silverlight;

namespace Galaktika.BI.Charting
{
    public static class SeriesFactory
    {
        public static bool SupportSeries(ChartSeries series)
        {
            if (SeriesFactory.GetSeries(series) == null)
                return false;
            return true;
        }

        public static bool IsSeriesWithAxes(ChartSeries series)
        {            
            switch (series.AViewType)
            {
                case ViewType.Pie:
                case ViewType.Pie3D:
                case ViewType.Doughnut3D:
                case ViewType.Doughnut:
                case ViewType.PolarArea:
                case ViewType.PolarLine:
                case ViewType.RadarArea:
                case ViewType.RadarLine:
                case ViewType.RadarPoint:                
                    return false; 
                default:
                    return true;
            }
        }

        public static Series GetSeries(ChartSeries series)
        {
            Series s;
            switch (series.AViewType)
            {
                case ViewType.Bar: 
                case ViewType.Bar3D:
                    {
                        s = new BarSeries();
                        s.Title = series.AName;
                        return (s as BarSeries);
                    }
                case ViewType.Doughnut:
                case ViewType.Doughnut3D:
                    {
                        s = new BubbleSeries();
                        s.Title = series.AName;
                        return (s as BubbleSeries);
                    }
                case ViewType.Line:
                case ViewType.Line3D:
                    {
                        s = new LineSeries();
                        s.Title = series.AName;
                        return (s as LineSeries);
                    }
                case ViewType.Point:
                    {
                        s = new ScatterSeries();
                        s.Title = series.AName;
                        return (s as ScatterSeries);
                    }
                case ViewType.Pie:
                case ViewType.Pie3D:
                    {
                        s = new PieSeries();
                        s.Title = series.AName;
                        return (s as PieSeries);
                    }
                case ViewType.Area:
                case ViewType.Area3D:
                    {
                        s = new AreaSeries();
                        s.Title = series.AName;
                        return (s as AreaSeries);
                    }
            }
            return null;
        }

        public static DataPointSeriesWithAxes GetSeriesWithAxes(ChartSeries series)
        {
            Series s;
            switch (series.AViewType)
            {
                case ViewType.Bar:
                case ViewType.Bar3D:
                    {
                        s = new BarSeries();
                        s.Title = series.AName;
                        return (s as BarSeries);
                    }
                case ViewType.Line:
                case ViewType.Line3D:
                    {
                        s = new LineSeries();
                        s.Title = series.AName;
                        return (s as LineSeries);
                    }
                case ViewType.Doughnut:
                case ViewType.Doughnut3D:
                    {
                        s = new BubbleSeries();
                        s.Title = series.AName;
                        return (s as BubbleSeries);
                    }
                case ViewType.Point:
                    {
                        s = new ScatterSeries();
                        s.Title = series.AName;
                        return (s as ScatterSeries);
                    }
                case ViewType.Area:
                case ViewType .Area3D:
                    {
                        s = new AreaSeries();
                        s.Title = series.AName;
                        return (s as AreaSeries);
                    }

            }
            return null;
        }
        public static T GetSeries<T>(ChartSeries series)
            where T: Series
        {
            try
            {
                var s = Activator.CreateInstance(typeof(T)) as T;
                return s;
            }
            catch (Exception e)
            {                
                throw new NotSupportedException(Localization.Exc_SeriesNotSupported,e);
            }                                 
        }
    }

    public class ChartSeriesViewHelper
    {
        private static ChartSeriesViewHelper m_ChartSeriesHelper;

        #region Constructors
        private ChartSeriesViewHelper()
        {
        }
        #endregion Constructors

        #region Private Properies
        private static ChartSeriesViewHelper Helper
        {
            get
            {
                if (m_ChartSeriesHelper == null)
                {
                    m_ChartSeriesHelper = new ChartSeriesViewHelper();
                }
                return m_ChartSeriesHelper;
            }
        }
        #endregion Private Properies

        #region Public Methods

        /// <summary>
        /// Возвращает массив строк, содержащий список видов серий, 
        /// которые поддерживаются диаграммой targetDiagram
        /// </summary>
        /// <param name="targetDiagram"></param>
        /// <returns></returns>
        //public static string[] GetSupportedViewTypes(Diagram targetDiagram)
        //{
        //    List<string> viewTypesAll = new List<string>(SeriesViewFactory.StringIDs);
        //    List<string> viewTypesSupported = new List<string>();
        //    foreach (string candidateViewTypeName in viewTypesAll)
        //    {
        //        ViewType viewType = SeriesViewFactory.GetViewType(candidateViewTypeName);
        //        if (SupportDiagram(viewType, targetDiagram))
        //        {
        //            viewTypesSupported.Add(candidateViewTypeName);
        //        }
        //    }

        //    return viewTypesSupported.ToArray();
        //}

        /// <summary>
        /// Возвращает вид серии по названию
        /// </summary>
        /// <returns></returns>
        public static ViewType GetViewType(string viewTypeName)
        {
            return ViewType.Line;//SeriesViewFactory.GetViewType(viewTypeName);
        }

        /// <summary>
        /// Возвращается серия по виду серии
        /// </summary>
        /// <param name="targetViewType">Тип вида серии</param>
        /// <returns></returns>
        public static Series GetView(ViewType targetViewType)
        {
            return  null;//(Series)SeriesViewFactory.CreateInstance(targetViewType);
        }

        /// <summary>
        /// Возвращает тип диаграммы в зависимости от серии
        /// </summary>
        /// <param name="seriesView">Серия, диаграмма которой определяется</param>
        /// <returns></returns>
        public static Series GetDiagram(Series seriesView)
        {
            //if (seriesView is GanttSeriesView)
            //    return new GanttDiagram();

            if (seriesView is BarSeries)
                return new BarSeries();

            if (seriesView is ScatterSeries)
                return new ScatterSeries();

            if (seriesView is BubbleSeries)
                return new BubbleSeries();

            if (seriesView is AreaSeries)
                return new AreaSeries();
            //if (seriesView is FinancialSeriesViewBase)
            //    return new XYDiagram();

            //if (seriesView is Bar3DSeriesView)
            //    return new XYDiagram3D();

            if (seriesView is LineSeries)
                return new LineSeries();

            //if (seriesView is PolarAreaSeriesView)
            //    return new PolarDiagram();

            //if (seriesView is PolarLineSeriesView)
            //    return new PolarDiagram();

            //if (seriesView is PolarPointSeriesView)
            //    return new PolarDiagram();

            //if (seriesView is RadarSeriesViewBase)
            //    return new RadarDiagram();

            if (seriesView is PieSeries)
                return new PieSeries();

            if (seriesView is ColumnSeries)
                return new ColumnSeries();

            
            return null;
        }

        /// <summary>
        /// Поддерживает ли текущая серия диаграмму targetDiagram
        /// </summary>
        /// <param name="series">Серия, для которой проверяется совместимость с диаграммой targetDiagram</param>
        /// <param name="targetDiagram">Диаграмма, соответствие с которой определяется</param>
        /// <returns></returns>
        /// <summary>
        public static bool SupportDiagram(ChartSeries series, Series targetDiagram)
        {
            // отсутствие диаграммы означает, что серия поддерживает диаграмму
            if (targetDiagram == null)
            {
                return true;
            }

            Series seriesView = null;//SeriesViewFactory.CreateInstance(series.AViewType);
            //Type seriesDiagramType = GetDiagram(seriesView).GetType();
            //Type targetDiagramType = targetDiagram.GetType();

            return true;//seriesDiagramType.Equals(targetDiagramType);
        }

        /// <summary>
        /// Поддерживает ли тип базовой серии диаграмму targetDiagram
        /// </summary>
        /// <param name="seriesView">Базовая серия, для которой проверяется совместимость с диаграммой targetDiagram</param>
        /// <param name="targetDiagram">Диаграмма, соответствие с которой определяется</param>
        /// <returns></returns>
        /// <summary>
        //public static bool SupportDiagram(SeriesViewBase seriesView, Diagram targetDiagram)
        //{
        //    // отсутствие диаграммы означает, что серия поддерживает диаграмму
        //    if (targetDiagram == null)
        //        return true;

        //    Type seriesDiagramType = GetDiagram(seriesView).GetType();
        //    Type targetDiagramType = targetDiagram.GetType();

        //    return seriesDiagramType.Equals(targetDiagramType);
        //}

        /// <summary>
        /// Поддерживает ли вид базовой серии диаграмму targetDiagram
        /// </summary>
        /// <param name="viewType">Вид базовой серии, для которого проверяется совместимость с диаграммой targetDiagram</param>
        /// <param name="targetDiagram">Диаграмма, соответствие с которой определяется</param>
        /// <returns></returns>
        /// <summary>
        //public static bool SupportDiagram(ViewType viewType, Diagram targetDiagram)
        //{
        //    // отсутствие сравниваемой диаграммы означает, что серия поддерживает диаграмму
        //    if (targetDiagram == null)
        //    {
        //        return true;
        //    }

        //    SeriesViewBase seriesView = SeriesViewFactory.CreateInstance(viewType);//ChartSeriesViewHelper.GetView(viewType);
        //    Type seriesDiagramType = GetDiagram(seriesView).GetType();
        //    Type targetDiagramType = targetDiagram.GetType();

        //    return seriesDiagramType.Equals(targetDiagramType);
        //}
        #endregion Public Methods
    }

}
